home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / benchmarks / pdev.mendel / RCS / timeIt.c,v < prev   
Text File  |  1992-04-10  |  3KB  |  157 lines
  1. head     1.2;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.2
  10. date     92.04.10.15.52.44;  author kupfer;  state Exp;
  11. branches ;
  12. next     1.1;
  13.  
  14. 1.1
  15. date     92.04.10.15.52.19;  author kupfer;  state Exp;
  16. branches ;
  17. next     ;
  18.  
  19.  
  20. desc
  21. @@
  22.  
  23.  
  24. 1.2
  25. log
  26. @Use "%03d" instead of "%-03d".
  27. @
  28. text
  29. @/* $Header$ */
  30.  
  31. #include <stdio.h>
  32. #include <sys/types.h>
  33. #include <sys/file.h>
  34. #include <sys/time.h>
  35. #include <signal.h>
  36. #include "pdev.h"
  37.  
  38. ReturnStatus writeSrv();
  39. ReturnStatus readSvr();
  40.  
  41. static Pdev_CallBacks pdevDefaultCallBacks = {
  42.      NULL,
  43.      readSvr,
  44.      writeSrv,
  45.      NULL,
  46.      NULL,
  47.      NULL,
  48.      NULL,
  49. };
  50.  
  51. main(arv)
  52. {
  53.     register int i;
  54.     int    junk1, junk2;
  55.     int starttime;
  56.     struct timeval stp, etp;
  57.     Pdev_Token    pdev;
  58.     int        fd;
  59.     int        size;
  60.     int        pid;
  61.     char        buf[8192];
  62.     char        *pdevName;
  63.  
  64.     pdev = Pdev_Open("./pdevD", &pdevName, 9000, 0, &pdevDefaultCallBacks, 0);
  65.     if (pdev == (Pdev_Token) NULL) {
  66.         printf("Can't open pdev\n");
  67.         exit(1);
  68.     }
  69.     printf("Using pdev %s\n", pdevName);
  70.     pid = fork();
  71.     if (pid != 0) {
  72.         while(1) {
  73.         Fs_Dispatch();
  74.         }
  75.     }
  76.     fd = open(pdevName, O_RDWR, 0);
  77.     if (fd < 0) {
  78.         perror("open");
  79.         exit(1);
  80.     }
  81.     bzero(buf,8192);
  82.     for (size = 1; size <= 8192; size *= 2) {
  83.         gettimeofday(&stp,0);
  84.         for (i = 0; i < 1000; i++) {
  85.         if (write(fd, buf, size) != size) {
  86.             perror("write");
  87.         }
  88.         }
  89.         gettimeofday(&etp,0);
  90.         fixtime(&stp,&etp);
  91.         printf("Write %d bytes 1000 times , time = %4d.%03d\n", size,
  92.         etp.tv_sec, etp.tv_usec/1000);
  93.     }
  94.     for (size = 1; size <= 8192; size *= 2) {
  95.         gettimeofday(&stp,0);
  96.         for (i = 0; i < 1000; i++) {
  97.         if (read(fd, buf, size) != size) {
  98.             perror("read");
  99.         }
  100.         }
  101.         gettimeofday(&etp,0);
  102.         fixtime(&stp,&etp);
  103.         printf("Read %d bytes 1000 times , time = %4d.%-03d\n", size,
  104.         etp.tv_sec, etp.tv_usec/1000);
  105.     }
  106.     killpg(getpgrp(0),SIGTERM);
  107. }
  108. fixtime(s, e)
  109.         struct  timeval *s, *e;
  110. {
  111.  
  112.         e->tv_sec -= s->tv_sec;
  113.         e->tv_usec -= s->tv_usec;
  114.         if (e->tv_usec < 0) {
  115.                 e->tv_sec--; e->tv_usec += 1000000;
  116.         }
  117. }
  118.  
  119. ReturnStatus
  120. writeSrv(streamPtr, async, writePtr, selectBitsPtr, sigPtr)
  121.               Pdev_Stream *streamPtr;   
  122.               int async;                
  123.               Pdev_RWParam *writePtr;   
  124.               int *selectBitsPtr;       
  125.               Pdev_Signal *sigPtr;  
  126. {
  127.  
  128.     *selectBitsPtr = FS_READABLE | FS_WRITABLE;
  129.     return(SUCCESS);
  130. }
  131. ReturnStatus
  132. readSvr(streamPtr, readPtr, freeItPtr, selectBitsPtr, sigPtr)
  133.               Pdev_Stream *streamPtr;  
  134.               Pdev_RWParam *readPtr;   
  135.               Boolean *freeItPtr;       
  136.               int *selectBitsPtr;       
  137.               Pdev_Signal *sigPtr;      
  138. {
  139.     *freeItPtr = FALSE;
  140.     *selectBitsPtr = FS_READABLE | FS_WRITABLE;
  141.     return(SUCCESS);
  142.  
  143. }
  144. @
  145.  
  146.  
  147. 1.1
  148. log
  149. @Initial revision
  150. @
  151. text
  152. @d1 2
  153. d63 1
  154. a63 1
  155.         printf("Write %d bytes 1000 times , time = %4d.%-03d\n", size,
  156. @
  157.